跳到主要内容

Tokenizer与BPE

Tokenizer 是模型的"入口"。模型看不到字符串,它只看到一串整数——tokenizer 干的就是"把字符串翻译成整数序列"这件事。这个环节非常朴素,但里面的选择直接影响模型的性能、上下文长度、多语言能力。

1. 最朴素的两种做法​

我们从两个极端开始想。

极端一:字符级。把每个字符当成一个 token。中文一个汉字一个 token,英文一个字母一个 token。词表非常小,几千个够了。但序列会变得非常长——"unhappiness"要 11 个 token,一个 1000 词的段落要 5000-6000 个 token。序列一长,注意力的 O(n²) 就受不了。

极端二:词级。把每个词当成一个 token。这样序列短了,但词表爆炸——英语几十万词、中文光常用词也十来万。而且 OOV(out-of-vocabulary)问题严重:训练时没见过的词就没法处理。比如你训练时词表里有 "run",测试时来一个 "running",词表里没有,模型只能吐个 [UNK]。

中间路线?——子词级(subword)。

2. 子词的核心思想​

子词的想法很简单:常见的词整个当一个 token,不常见的词切成若干个常见的片段。

比如 "unhappiness",可能被切成 ["un", "happi", "ness"] 三个 token。这三个子词都是常见的,词表里都有。这样:

  • 常见词效率高("the"、"and" 都是一个 token);
  • 罕见词也能表示(拆成子词);
  • 没见过的词也能处理(拆成见过的子词组合)。

这就解决了词级方法的 OOV 问题,又比字符级方法紧凑得多。

问题变成了:怎么决定哪些拼在一起、哪些切开?

3. BPE:合并最频繁的对​

BPE(Byte-Pair Encoding) 是最主流的子词算法。GPT-2/3/4、LLaMA、Qwen 都用它的变体。

算法本身极其朴素。想象我们从"每个字符一个 token"这个最细的粒度开始,然后一步一步"合并"最频繁的一对:

第 0 步:初始词表是所有单个字符。每个词都被切成字符序列。

第 1 步:统计所有相邻字符对的出现频次。找出频次最高的那对,比如 ("e", "s") 出现了 3 万次,最高。把这对合并:新词表里多一个 token "es",语料里所有 "e" "s" 相邻的地方都被替换成 "es"。

第 2 步:重复。假设现在最频繁的是 ("es", "t"),合并成 "est"。

第 3 步、第 4 步…… 一直合并,直到词表达到你设定的大小(比如 32k、100k、200k)。

就是这么简单。合并次数就是"新增的 token 数",最终词表大小 = 初始字符数 + 合并次数。

举个例子。假设我们的语料里有这几个词:low, lowest, newer, wider,词频比例假设是 5:2:6:3。BPE 一开始把它们全切成字符:

l o w         (×5)
l o w e s t (×2)
n e w e r (×6)
w i d e r (×3)

第一轮统计相邻对:(l,o) 出现 7 次,(o,w) 出现 7 次,(e,r) 出现 9 次,……。最高是 (e,r),合并。

l o w         (×5)
l o w e s t (×2)
n e w er (×6)
w i d er (×3)

第二轮又统计,最高可能是 (l,o),合并成 lo。就这么持续下去,最后你会看到 low、er 这些常见子串都变成一个 token,罕见的字符组合还是单字符。

这个思路的漂亮之处:合并规则完全从数据里学出来。你不需要什么先验语言学知识,语料里高频的东西自然会成为 token。

4. Byte-level BPE:GPT 的选择​

原始 BPE 有个坑:处理 Unicode 时词表会爆。中文、日文、韩文加起来几万个字符,每个字符都要占一个"初始 token"。

GPT-2 用了一个非常聪明的技巧:Byte-level BPE。

它不在"字符"上做 BPE,而是在 UTF-8 字节序列上做 BPE。UTF-8 字节只有 256 种,初始词表就是 256——覆盖世界上所有语言。中文汉字在 UTF-8 里是 3 个字节,一个汉字最开始就是 3 个 token。然后让 BPE 去合并——常用的汉字组合会被合并成一个 token,罕见的还是 3 个字节。

好处:真正的"处理任何 Unicode 字符串",永远不会 OOV。代价:对中文不太友好——一个汉字在初始状态下要 3 个 token,合并之后好一点,但整体上中文的 token/字符比比英文高。

LLaMA、Qwen 都用 Byte-level BPE。区别在于 tokenizer 训练用的语料——如果多语言语料多,中文的 token 效率就更好。

5. 对中文的影响​

中文一个字大约等于多少 token? 这个数字直接决定你的上下文预算。

  • GPT-4(英语为主的语料训练):中文大约 1 字 ≈ 1.5-2 token。
  • Qwen / DeepSeek(中英双语训练):中文大约 1 字 ≈ 1-1.2 token。

所以同样是 128K 上下文的模型,GPT-4 用中文只能塞 70K 字左右,而 Qwen 能塞 100K+ 字。这是选中文模型时一个非常实际的考虑。

对英文来说:1 词 ≈ 1.3 token(常用词一个 token,长词或罕见词多个 token)。

6. 一些其他的分词算法​

BPE 不是唯一选择,但它是主流。简单提一下另外两个:

WordPiece(BERT 用的)。和 BPE 非常像,只有一个区别:BPE 每一步选"频次最高的对",WordPiece 选"合并后能最大化训练语料似然的对"。实际效果和 BPE 差不多,实现更复杂一点。已经不太流行了。

SentencePiece(T5、LLaMA 用它作为训练框架)。它更像是一个"工程框架",可以在字节级、字符级都跑,可以跑 BPE 也可以跑 Unigram LM。LLaMA 用的是 SentencePiece 跑的 BPE。

Unigram LM。假设整个语料是从一个"unigram 语言模型"里采样出来的,把每个词的 log 似然作为损失,反向选择要保留哪些子词。相比 BPE 更"全局最优"一点,但代价是训练慢。SentencePiece 支持它。

大部分情况下你不需要区分这些——主流就是 BPE。

7. 一些实践细节​

特殊 token。除了普通词,词表里还会预留一些特殊标记:<bos>(序列开始)、<eos>(结束)、<pad>(填充)、<unk>(未知词,byte-level 下用不到)等等。对话模型还会多一堆 <|im_start|>、<|im_end|>、<|system|> 之类的角色标记。这些 token 通常是手动加进词表的,不参与 BPE 训练。

加不加前置空格。GPT 系列有个古怪的设定:一个词前面有没有空格,被认为是两个不同的 token。"apple" 和 " apple"(前面带空格)是两个不同的 id。原因是英文里"the apple"和"apple pie"应该被不同处理。这个设计让 tokenizer 对空格非常敏感——你在 prompt 结尾加不加空格,模型会给出完全不同的输出。这是很多 prompt engineering bug 的根源。

词表大小的取舍。词表大 → 序列短、上下文效率高;但 embedding 层和输出层的参数量 ∝ 词表 × d,词表大了两头都涨。主流 LLM 词表大概在 32k-200k 之间:LLaMA-1 是 32k、LLaMA-2 是 32k、LLaMA-3 是 128k、Qwen 是 152k、DeepSeek 是 100k。中文/多语言需求高的模型词表大一些。

多语言效率。词表是从训练语料里长出来的。你的 tokenizer 训练时中文语料多,中文的 token 效率就高;反之效率就低。这直接影响你在这门语言上的推理成本——同样一段话,中文效率高的 tokenizer token 数少,推理成本也就少。

8. Tokenizer 和模型是耦合的​

一个非常重要的、经常被忽视的事情:tokenizer 和模型是绑定的。

你不能用 LLaMA 的 tokenizer 去切一段文本,然后喂给 Qwen 的模型——它们的 vocab id 完全不一样。模型的 embedding 层是根据自己的 tokenizer 的 id 训练出来的,换一个 tokenizer 等于把 embedding 表全打乱。

所以每个模型仓库里一定会带着自己的 tokenizer.json / vocab.json / merges.txt。用哪家模型就用哪家 tokenizer。

而且:这也是"扩词表"很麻烦的原因。如果你想给一个英文模型加更多中文能力,你可能想扩展词表加更多中文 token。但新加的 token 在 embedding 表里是随机初始化的——模型不认识它们。要么大量再训练让它们学到含义,要么用平均已有 embedding 做初始化再微调。总之不是零成本的操作。

9. 一个实操:算一下你的 prompt 有多少 token​

在实际用 API 或者部署模型的时候,"这段话有多少 token"是个每天都要面对的问题。方法很简单:

from transformers import AutoTokenizer

tok = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-7B")
ids = tok.encode("今天天气真好,我们出去玩吧。")
print(len(ids), ids)
print(tok.convert_ids_to_tokens(ids))

跑一下你会看到每个 token 长什么样。对中文来说,你能直观感受到"一个汉字大概几个 token"。这个感觉在做长文档、做成本估计时非常有用。

OpenAI 提供了一个在线工具(tiktokenizer)让你直接看,或者用 tiktoken 库自己算。其他模型都是 HuggingFace 的 AutoTokenizer 一把梭。

10. 一些容易踩的坑​

"数数"能力被 tokenizer 限制。经典问题:"strawberry 里有几个 r?"很多模型答不对。原因是 tokenizer 把 "strawberry" 切成了 ["straw", "berry"],模型从来没见过单个字母 r。这不是"模型笨",是 tokenizer 的信息在字母层面被抹掉了。

数字被切得乱七八糟。"12345" 可能被切成 ["1", "2345"] 或者 ["123", "45"],全看训练语料里出现频次。这直接影响模型的算术能力——它看不到"个位、十位",只看到一坨。LLaMA-3 对数字做了特殊处理(每一位都单独一个 token),这在算术任务上有明显提升。

JSON 敏感。JSON 里的 {"key": "value"} 里 ":、",、"} 这些常见组合会被 BPE 合并成单个 token。改变缩进、加不加空格,token 数可能差很多。这也是为什么 "output JSON" 的效果会和缩进风格挂钩。

处理罕见语言。如果你的应用要处理 tokenizer 语料里没怎么覆盖到的语言(比如某些小语种、编程语言的少见语法),token 效率会突然掉下来——一句话可能要三倍的 token 数。这在成本估计和上下文预算里要留意。

11. 一句话总结​

Tokenizer 表面上朴素,实际上是整个 LLM 系统的性能地基:

  • 它决定了同样长度的字符串会消耗多少上下文预算;
  • 它决定了模型对字母、数字、罕见语言的"分辨率";
  • 它是模型的一部分,不能随便换。

下一章我们看看有了 tokenizer 之后,怎么在几万亿 token 的语料上把模型训出来——这就是预训练和 Scaling Law 的故事。